#ifndef __M_GOBANG_SERVER_HPP__
#define __M_GOBANG_SERVER_HPP__

#include <iostream>
#include <vector>
#include <string>
#include <functional>
#include <websocketpp/server.hpp>
#include <websocketpp/config/asio_no_tls.hpp>
#include "db.hpp"
#include "logger.hpp"
#include "matcher.hpp"
#include "online.hpp"
#include "room.hpp"
#include "session.hpp"
#include "util.hpp"

#define WWWROOT "./wwwroot/"

class gobang_server
{
private:
    void file_handler(const wsserver_t::connection_ptr &conn)
    {
        // 1.获取uri请求路径
        websocketpp::http::parser::request req = conn->get_request(); // 获取http请求对象
        std::string uri = req.get_uri();                              // 获取http请求uri
        // 2.组合出实际路径  相对根目录+uri
        std::string realpath = _web_root + uri;
        // 3.如果请求的是一个目录，则拼接login.html
        if (realpath.back() == '/')
            realpath += "login.html";
        // 4.读取文件
        std::string body;
        bool ret = file_util::read(realpath, body);
        if (ret == false)
        {
            // 文件打开失败或者读取失败，都返回404错误页面
            body += "<html>";
            body += "<head>";
            body += "<meta charset='UTF-8'/>";
            body += "</head>";
            body += "<body>";
            body += "<h1> Not Found </h1>";
            body += "</body>";
            body += "</html>";
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }

        // 4.发送响应
        conn->set_status(websocketpp::http::status_code::ok);
        conn->append_header("Content-Length", std::to_string(body.size()));
        conn->set_body(body);
        return;
    }

    void http_resp(const wsserver_t::connection_ptr &conn, bool result, websocketpp::http::status_code::value code, const std::string &reason)
    {
        Json::Value resp_json;
        resp_json["result"] = result;
        resp_json["reason"] = reason;
        std::string body;
        json_util::serialize(resp_json, body);
        conn->set_status(code);
        conn->set_body(body);
        conn->append_header("Content-Type", "application/json");
        return;
    }

    void reg(const wsserver_t::connection_ptr &conn)
    {
        // 1.获取请求正文
        std::string body = conn->get_request_body();
        // 2.对正文进行反序列化，得到用户名和密码
        Json::Value register_info;
        bool ret = json_util::unserialize(body, register_info);
        if (ret == false)
        {
            DLOG("反序列化注册信息失败!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求正文格式错误");
        }
        // 3.进行数据库的用户增加操作
        if (register_info["username"].isNull() || register_info["password"].isNull())
        {
            DLOG("用户名密码不完整!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名和密码");
        }
        ret = _ut.insert(register_info);
        if (ret == false)
        {
            DLOG("向数据库插入数据失败!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名已经被占用");
        }
        return http_resp(conn, true, websocketpp::http::status_code::ok, "注册用户成功");
    }

    void login(const wsserver_t::connection_ptr &conn)
    {
        // 1.获取请求正文
        std::string body = conn->get_request_body();
        // 2.对正文进行反序列化得到用户名和密码
        Json::Value login_info;
        bool ret = json_util::unserialize(body, login_info);
        if (ret == false)
        {
            DLOG("反序列化登录信息失败!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求正文格式错误");
        }
        // 3.进行用户名和密码完整性校验
        if (login_info["username"].isNull() || login_info["password"].isNull())
        {
            DLOG("用户名密码不完整!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名和密码");
        }
        ret = _ut.login(login_info);
        if (ret == false)
        {
            DLOG("用户名密码错误!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名密码错误");
        }
        // 4.登录成功为其创建session
        uint64_t uid = login_info["id"].asInt64();
        session_ptr ssp = _sm.create_session(uid, LOGIN);
        if (ssp.get() == nullptr)
        {
            DLOG("创建session会话失败!!!");
            return http_resp(conn, false, websocketpp::http::status_code::internal_server_error, "创建session会话失败");
        }
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT); // 设置过期时间
        // 4.设置响应头部，通过Set-Cookie将sessionID通过cookie返回
        std::string cookie_ssid = "SSID=" + std::to_string(ssp->ssid());
        conn->append_header("Set-Cookie", cookie_ssid);
        return http_resp(conn, true, websocketpp::http::status_code::ok, "登录成功");
    }

    bool get_cookie_val(const std::string &cookie_str, const std::string &key, std::string &val)
    {
        // Cookie字段格式
        // Cookie: SSID=XXX; path=/;
        // 1.以; 作为间隔，对字符串进行分割，得到各个单个的cookie信息
        std::string sep = "; ";
        std::vector<std::string> cookie_arry;
        string_util::split(cookie_str, sep, cookie_arry);
        for (auto &str : cookie_arry)
        {
            // 2.对单个cookie字符串以"="为间隔进行分割得到key和val
            std::vector<std::string> arr;
            string_util::split(str, "=", arr);
            if (arr.size() != 2)
                continue;
            if (arr[0] == key)
            {
                val = arr[1];
                return true;
            }
        }
        return false;
    }

    /*用户信息获取功能请求处理*/
    void info(const wsserver_t::connection_ptr &conn)
    {
        // 1.获取请求信息中的Cookie,从Cookie中获取ssid
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            DLOG("没有找到Cookie信息!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "找不到Cookie信息，请重新登录");
        }
        // 2.从cookie中获取到ssid
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            DLOG("从Cookie中取出SSID失败!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "找不到Cookie信息，请重新登录");
        }
        // 3.通过ssid获取到session信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            DLOG("获取session信息失败!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "登录过期，请重新登录");
        }
        // 4.通过session信息获取到用户信息
        uint64_t uid = ssp->get_user();
        Json::Value user_info;
        ret = _ut.select_by_id(uid, user_info);
        if (ret == false)
        {
            DLOG("获取用户信息失败!!!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "找不到用户信息，请重新登录");
        }
        // 5.构建响应
        std::string body;
        json_util::serialize(user_info, body);
        conn->set_body(body);
        conn->append_header("Content-Type", "application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        // 6.重置session过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    /*http请求回调函数*/
    void http_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl); // 获取connection_hdl对应的连接的connection_ptr
        websocketpp::http::parser::request req = conn->get_request();   // 获取http请求对象
        std::string method = req.get_method();                          // 获取请求方法
        std::string uri = req.get_uri();                                // 获取请求url
        // 对于HTTP来说，分为两种资源，一种是静态资源，一种是动态资源
        if (method == "POST" && uri == "/reg")
        {
            // 动态资源请求
            // 注册信息上传
            reg(conn);
        }
        else if (method == "POST" && uri == "/login")
        {
            // 动态资源请求
            // 登录信息上传
            login(conn);
        }
        else if (method == "GET" && uri == "/info")
        {
            // 动态资源请求
            // 需要获取对应用户信息
            info(conn);
        }
        else
        {
            // 静态资源请求
            // 单纯获取静态页面
            return file_handler(conn);
        }
    }

    session_ptr get_session_by_cookie(const wsserver_t::connection_ptr &conn, const std::string &ops)
    {
        Json::Value err_resp;
        // 1.获取Cookie信息
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // 没有cookie字段信息，返回错误信息
            err_resp["optype"] = ops;
            err_resp["result"] = false;
            err_resp["reason"] = "没有找到Cookie信息，请重新登录";
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        // 2.获取SSID
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            // 没有SSID,返回错误信息
            err_resp["optype"] = ops;
            err_resp["result"] = false;
            err_resp["reason"] = "没有找到SSID信息，请重新登录";
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        // 3.通过ssid获取session信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            // 没有session信息，返回错误信息
            err_resp["optype"] = ops;
            err_resp["result"] = false;
            err_resp["reason"] = "没有找到session信息，请重新登录";
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        return ssp;
    }

    void ws_resp(const wsserver_t::connection_ptr &conn, const Json::Value &resp)
    {
        std::string body;
        json_util::serialize(resp, body);
        conn->send(body);
        return;
    }

    /*游戏大厅长连接建立*/
    void wsopen_game_hall(const wsserver_t::connection_ptr &conn)
    {
        Json::Value resp_json;
        // 1.判断当前客户端是否登录
        session_ptr ssp = get_session_by_cookie(conn, "hall_ready");
        if (ssp.get() == nullptr)
            return;
        // 2.判断当前客户端是否重复登录
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "玩家重复登录";
            return ws_resp(conn, resp_json);
        }
        // 3.将当前客户端连接加入到在线管理模块_om中进行管理(游戏大厅)
        _om.enter_game_hall(ssp->get_user(), conn);
        // 4.给客户端返回成功的响应
        resp_json["optype"] = "hall_ready";
        resp_json["result"] = true;
        ws_resp(conn, resp_json);
        // 5.将session设置为永久
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
    }

    void wsopen_game_room(const wsserver_t::connection_ptr &conn)
    {
        Json::Value resp_json;
        // 1.判断当前客户端是否登录
        session_ptr ssp = get_session_by_cookie(conn, "room_ready");
        if (ssp.get() == nullptr)
            return;
        // 2.判断当前客户端是否重复登录
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            resp_json["optype"] = "room_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "玩家重复登录";
            return ws_resp(conn, resp_json);
        }
        // 3.判断当前客户端是否创建好了房间
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr)
        {
            resp_json["optype"] = "room_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "没有找到玩家对应的房间信息";
            return ws_resp(conn, resp_json);
        }
        // 4.将当前客户端添加进行在线管理模块_om中进行管理(游戏房间)
        _om.enter_game_room(ssp->get_user(), conn);
        // 5.将当前客户端的session设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
        // 6.构建成功响应，发送回客户端
        resp_json["optype"] = "room_ready";
        resp_json["result"] = true;
        resp_json["room_id"] = (Json::UInt64)rp->id();
        resp_json["uid"] = (Json::UInt64)ssp->get_user();
        resp_json["white_id"] = (Json::UInt64)rp->get_white_user();
        resp_json["black_id"] = (Json::UInt64)rp->get_black_user();
        return ws_resp(conn, resp_json);
    }

    /*websocket长连接建立之后的处理函数*/
    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
        // 1.获取websocket连接
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        // 2.获取请求对象
        websocketpp::http::parser::request req = conn->get_request();
        // 3.获取uri
        std::string uri = req.get_uri();
        // 4.根据uri调用不同的处理函数
        if (uri == "/hall")
        {
            // 建立游戏大厅的长连接
            return wsopen_game_hall(conn);
        }
        else if (uri == "/room")
        {
            // 建立游戏房间的长连接
            return wsopen_game_room(conn);
        }
    }

    /*游戏大厅长连接断开处理*/
    void wsclose_game_hall(const wsserver_t::connection_ptr &conn)
    {
        // 1.判断是否登录
        session_ptr ssp = get_session_by_cookie(conn, "hall_ready");
        if (ssp.get() == nullptr)
            return;
        // 2.从在线用户管理模块_om中移除(游戏大厅)
        _om.exit_game_hall(ssp->get_user());
        // 3.将session的生命周期设置为有效时间后删除
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    /*游戏房间长连接断开处理*/
    void wsclose_game_room(const wsserver_t::connection_ptr &conn)
    {
        // 1.判断是否登录
        session_ptr ssp = get_session_by_cookie(conn, "room_ready");
        if (ssp.get() == nullptr)
            return;
        // 2.从在线管理模块_om中移除(游戏房间)
        _om.exit_game_room(ssp->get_user());
        // 3.将session生命周期设置为有效时间后删除
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        // 4.将玩家从游戏房间内移除，当游戏房间内用户人数为0时，销毁游戏房间
        _rm.remove_room_user(ssp->get_user());
    }

    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        // 1.获取websocket连接
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        // 2.获取请求对象
        websocketpp::http::parser::request req = conn->get_request();
        // 3.获取uri
        std::string uri = req.get_uri();
        // 4.根据uri的不同调用不同的处理函数
        if (uri == "/hall")
        {
            // 断开游戏大厅的长连接
            return wsclose_game_hall(conn);
        }
        else if (uri == "/room")
        {
            // 断开游戏房间的长连接
            return wsclose_game_room(conn);
        }
    }

    void wsmsg_game_hall(const wsserver_t::connection_ptr &conn, wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        // 1.判断是否登录(进行身份的有效验证)
        session_ptr ssp = get_session_by_cookie(conn, "unknow");
        if (ssp.get() == nullptr)
            return;
        // 2.获取请求信息
        std::string req_body = msg->get_payload();
        Json::Value req_json;
        bool ret = json_util::unserialize(req_body, req_json);
        if (ret == false)
        {
            resp_json["result"] = false;
            resp_json["reason"] = "请求信息处理失败";
            return ws_resp(conn, resp_json);
        }
        // 3.对于请求进行处理
        if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start")
        {
            // 开始进行匹配对战
            _mm.add(ssp->get_user()); // 添加进匹配队列中进行匹配
            resp_json["optype"] = "match_start";
            resp_json["result"] = true;
            return ws_resp(conn, resp_json);
        }
        else if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop")
        {
            // 停止对战匹配
            _mm.del(ssp->get_user());
            resp_json["optype"] = "match_stop";
            resp_json["result"] = true;
            return ws_resp(conn, resp_json);
        }
        else
        {
            // 未知的请求类型
            resp_json["optype"] = "unknow";
            resp_json["result"] = false;
            resp_json["reason"] = "请求类型未知";
            return ws_resp(conn, resp_json);
        }
    }

    void wsmsg_game_room(const wsserver_t::connection_ptr &conn, wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        // 1.判断是否登录(进行身份验证)
        session_ptr ssp = get_session_by_cookie(conn, "unknow");
        if (ssp.get() == nullptr)
            return;
        //2.获取客户端房间信息
        room_ptr rp=_rm.get_room_by_uid(ssp->get_user());
        if(rp.get()==nullptr)
        {
            resp_json["optype"]="unknow";
            resp_json["result"]=false;
            resp_json["reason"]="没有找到玩家房间信息";
            DLOG("房间-没有找到玩家房间信息!!!");
            return ws_resp(conn,resp_json);
        }
        //3.获取请求正文
        std::string req_body=msg->get_payload();
        //4.对请求正文进行反序列化
        Json::Value req_json;
        bool ret=json_util::unserialize(req_body,req_json);
        if(ret==false)
        {
            resp_json["optype"]="unknow";
            resp_json["result"]=false;
            resp_json["reason"]="请求解析失败!!!";
            DLOG("房间-反序列化请求失败!!!");
            return ws_resp(conn,resp_json);
        }
        DLOG("房间:收到房间请求，开始进行处理.....");
        return rp->handle_request(req_json);
    }

    void wsmsg_callback(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msg)
    {
        // 1.获取websocket长连接
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        // 2.获取请求对象
        websocketpp::http::parser::request req = conn->get_request();
        // 3.获取uri
        std::string uri = req.get_uri();
        // 4.根据不同的uri调用不同的处理函数处理
        if (uri == "/hall")
        {
            // 处理游戏大厅消息请求
            wsmsg_game_hall(conn, msg);
        }
        else if (uri == "/room")
        {
            // 处理游戏房间消息请求
            wsmsg_game_room(conn, msg);
        }
    }

public:
    gobang_server(const std::string &host, const std::string &user, const std::string &password,
                  const std::string &db, uint16_t port = 3306, std::string web_root = WWWROOT)
        : _web_root(web_root), _ut(host, user, password, db, port), _rm(&_ut, &_om), _sm(&_wssrv), _mm(&_rm, &_ut, &_om)
    {
        // websocketpp::log::alevel::none 禁止打印所有日志
        _wssrv.set_access_channels(websocketpp::log::alevel::none); // 设置打印等级
        _wssrv.init_asio();                                         // 初始化asio调度器
        _wssrv.set_reuse_addr(true);                                // 设置启用地址重用
        // 设置各类回调函数
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));                            // 设置http请求回调处理函数
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));                          // 设置websocket握手成功回调处理函数
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));                        // 设置websocket连接关闭回调处理函数
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback, this, std::placeholders::_1, std::placeholders::_2)); // 设置websocket消息回调处理函数
    }

    void start(int port = 8080)
    {
        _wssrv.listen(port);
        _wssrv.start_accept();
        _wssrv.run();
    }

private:
    std::string _web_root; // 静态资源根目录  /wwwroot
    wsserver_t _wssrv;     // websocket对象
    user_table _ut;        // 数据库管理对象
    online_manager _om;    // 在线用户管理对象
    room_manager _rm;      // 游戏房间管理对象
    session_manager _sm;   // session管理对象
    matcher _mm;           // 匹配队列管理对象
};

#endif